ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್: ದೃಢವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ ಸಂಕೀರ್ಣ ಡೇಟಾ ಪ್ರಕಾರಗಳಲ್ಲಿ ಪರಿಣತಿ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಒಂದು ಸೂಪರ್‌ಸೆಟ್ ಆಗಿದ್ದು, ಡೆವಲಪರ್‌ಗಳಿಗೆ ಸ್ಟ್ಯಾಟಿಕ್ ಟೈಪಿಂಗ್ ಮೂಲಕ ಹೆಚ್ಚು ದೃಢವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲ ಕೋಡ್ ಬರೆಯಲು ಅಧಿಕಾರ ನೀಡುತ್ತದೆ. ಇದರ ಅತ್ಯಂತ ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ ಜೆನೆರಿಕ್ಸ್ ಕೂಡಾ ಒಂದು, ಇದು ನಿಮಗೆ ಟೈಪ್ ಸೇಫ್ಟಿಯನ್ನು ಕಾಯ್ದುಕೊಂಡು ವಿವಿಧ ಡೇಟಾ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಲ್ಲ ಕೋಡ್ ಬರೆಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್‌ಗಳ ಬಗ್ಗೆ ಸಮಗ್ರ ಪರಿಶೋಧನೆಯನ್ನು ನೀಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಜಾಗತಿಕ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಕೀರ್ಣ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗೆ ಅವುಗಳ ಅನ್ವಯವನ್ನು ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ.

ಜೆನೆರಿಕ್ಸ್ ಎಂದರೇನು?

ಜೆನೆರಿಕ್ಸ್ ವಿವಿಧ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಲ್ಲ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಕೋಡ್ ಬರೆಯಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನೀವು ಬೆಂಬಲಿಸಲು ಬಯಸುವ ಪ್ರತಿಯೊಂದು ಪ್ರಕಾರಕ್ಕೂ ಪ್ರತ್ಯೇಕ ಫಂಕ್ಷನ್‌ಗಳು ಅಥವಾ ಕ್ಲಾಸ್‌ಗಳನ್ನು ಬರೆಯುವ ಬದಲು, ನೀವು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಬಳಸುವ ಒಂದೇ ಫಂಕ್ಷನ್ ಅಥವಾ ಕ್ಲಾಸ್ ಅನ್ನು ಬರೆಯಬಹುದು. ಈ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಫಂಕ್ಷನ್ ಅಥವಾ ಕ್ಲಾಸ್ ಅನ್ನು ಕಾಲ್ ಮಾಡಿದಾಗ ಅಥವಾ ಇನ್‌ಸ್ಟಾನ್ಶಿಯೇಟ್ ಮಾಡಿದಾಗ ಬಳಸಲಾಗುವ ನಿಜವಾದ ಪ್ರಕಾರಗಳಿಗೆ ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್‌ಗಳಾಗಿವೆ. ಸಂಕೀರ್ಣ ಡೇಟಾ ರಚನೆಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಏಕೆಂದರೆ ಆ ರಚನೆಗಳಲ್ಲಿನ ಡೇಟಾದ ಪ್ರಕಾರವು ಬದಲಾಗಬಹುದು.

ಜೆನೆರಿಕ್ಸ್ ಬಳಸುವುದರ ಪ್ರಯೋಜನಗಳು

• ಕೋಡ್ ಮರುಬಳಕೆ: ಒಮ್ಮೆ ಕೋಡ್ ಬರೆಯಿರಿ ಮತ್ತು ಅದನ್ನು ವಿವಿಧ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಬಳಸಿ. ಇದು ಕೋಡ್ ನಕಲು ಮಾಡುವುದನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್‌ಬೇಸ್ ಅನ್ನು ಹೆಚ್ಚು ನಿರ್ವಹಿಸಬಲ್ಲದು ಮಾಡುತ್ತದೆ.
• ಟೈಪ್ ಸೇಫ್ಟಿ: ಜೆನೆರಿಕ್ಸ್ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಕಂಪೈಲರ್‌ಗೆ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಟೈಪ್ ಸೇಫ್ಟಿಯನ್ನು ಜಾರಿಗೊಳಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ಟೈಪ್ ಹೊಂದಾಣಿಕೆಯಾಗದ ಕಾರಣದಿಂದ ಉಂಟಾಗುವ ರನ್‌ಟೈಮ್ ದೋಷಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
• ಸುಧಾರಿತ ಓದುವಿಕೆ: ನಿಮ್ಮ ಫಂಕ್ಷನ್‌ಗಳು ಮತ್ತು ಕ್ಲಾಸ್‌ಗಳು ಯಾವ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸುವ ಮೂಲಕ ಜೆನೆರಿಕ್ಸ್ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲದು ಮಾಡುತ್ತದೆ.
• ವರ್ಧಿತ ಕಾರ್ಯಕ್ಷಮತೆ: ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಜೆನೆರಿಕ್ಸ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸುಧಾರಣೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು ಏಕೆಂದರೆ ಕಂಪೈಲರ್ ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರಗಳನ್ನು ಆಧರಿಸಿ ರಚಿಸಲಾದ ಕೋಡ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಬಹುದು.

ಜೆನೆರಿಕ್ಸ್‌ಗಳ ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್

ಜೆನೆರಿಕ್ಸ್‌ಗಳ ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್ ಆಂಗಲ್ ಬ್ರಾಕೆಟ್‌ಗಳನ್ನು (< >) ಬಳಸಿ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಘೋಷಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ T, K, V, ಇತ್ಯಾದಿ ಎಂದು ಹೆಸರಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ನೀವು ಯಾವುದೇ ಮಾನ್ಯ ಐಡೆಂಟಿಫೈಯರ್ ಅನ್ನು ಬಳಸಬಹುದು. ಜೆನೆರಿಕ್ ಫಂಕ್ಷನ್‌ನ ಒಂದು ಸರಳ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);
let myBoolean: boolean = identity<boolean>(true);

console.log(myString); // ಔಟ್‌ಪುಟ್: hello
console.log(myNumber); // ಔಟ್‌ಪುಟ್: 123
console.log(myBoolean); // ಔಟ್‌ಪುಟ್: true

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, <T> ಎಂಬುದು T ಹೆಸರಿನ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ. identity ಫಂಕ್ಷನ್ T ಪ್ರಕಾರದ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು T ಪ್ರಕಾರದ ಮೌಲ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಫಂಕ್ಷನ್ ಅನ್ನು ಕಾಲ್ ಮಾಡುವಾಗ, ನೀವು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು (ಉದಾ., identity<string>) ಅಥವಾ ಆರ್ಗ್ಯುಮೆಂಟ್ ಪ್ರಕಾರವನ್ನು ಆಧರಿಸಿ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಅದನ್ನು ಊಹಿಸಲು ಬಿಡಬಹುದು.

ಸಂಕೀರ್ಣ ಡೇಟಾ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು

ಅರೇಗಳು, ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಮತ್ತು ಇಂಟರ್ಫೇಸ್‌ಗಳಂತಹ ಸಂಕೀರ್ಣ ಡೇಟಾ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಜೆನೆರಿಕ್ಸ್ ವಿಶೇಷವಾಗಿ ಮೌಲ್ಯಯುತವಾಗುತ್ತದೆ. ಕೆಲವು ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ:

ಜೆನೆರಿಕ್ ಅರೇಗಳು

ವಿವಿಧ ಪ್ರಕಾರಗಳ ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಫಂಕ್ಷನ್‌ಗಳು ಅಥವಾ ಕ್ಲಾಸ್‌ಗಳನ್ನು ರಚಿಸಲು ನೀವು ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಬಳಸಬಹುದು:

function arrayToString<T>(arr: T[]): string {
  return arr.join(", ");
}

let numberArray: number[] = [1, 2, 3, 4, 5];
let stringArray: string[] = ["apple", "banana", "cherry"];

console.log(arrayToString(numberArray)); // ಔಟ್‌ಪುಟ್: 1, 2, 3, 4, 5
console.log(arrayToString(stringArray)); // ಔಟ್‌ಪುಟ್: apple, banana, cherry

ಇಲ್ಲಿ, arrayToString ಫಂಕ್ಷನ್ T[] ಪ್ರಕಾರದ ಅರೇಯನ್ನು ತೆಗೆದುಕೊಂಡು ಅರೇಯ ಸ್ಟ್ರಿಂಗ್ ನಿರೂಪಣೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಈ ಫಂಕ್ಷನ್ ಯಾವುದೇ ಪ್ರಕಾರದ ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಇದು ಹೆಚ್ಚು ಮರುಬಳಕೆ ಮಾಡಬಲ್ಲದು.

ಜೆನೆರಿಕ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು

ವಿವಿಧ ಆಕಾರಗಳ ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಫಂಕ್ಷನ್‌ಗಳು ಅಥವಾ ಕ್ಲಾಸ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಸಹ ಬಳಸಬಹುದು:

interface Person {
  name: string;
  age: number;
  country: string; // ಜಾಗತಿಕ ಸಂದರ್ಭಕ್ಕಾಗಿ ದೇಶವನ್ನು ಸೇರಿಸಲಾಗಿದೆ
}

interface Product {
  id: number;
  name: string;
  price: number;
  currency: string; // ಜಾಗತಿಕ ಸಂದರ್ಭಕ್ಕಾಗಿ ಕರೆನ್ಸಿಯನ್ನು ಸೇರಿಸಲಾಗಿದೆ
}

function displayInfo<T extends { name: string }>(item: T): void {
  console.log(`Name: ${item.name}`);
}

let person: Person = { name: "Alice", age: 30, country: "USA" };
let product: Product = { id: 1, name: "Laptop", price: 1200, currency: "USD" };

displayInfo(person); // ಔಟ್‌ಪುಟ್: Name: Alice
displayInfo(product); // ಔಟ್‌ಪುಟ್: Name: Laptop

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, displayInfo ಫಂಕ್ಷನ್ T ಪ್ರಕಾರದ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅದು ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರದ name ಪ್ರಾಪರ್ಟಿಯನ್ನು ಹೊಂದಿರಬೇಕು. extends { name: string } ಎಂಬುದು ಒಂದು ನಿರ್ಬಂಧ (constraint), ಇದು T ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ಕನಿಷ್ಠ ಅವಶ್ಯಕತೆಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಇದು ಫಂಕ್ಷನ್ name ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದೆಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಸುಧಾರಿತ ಜೆನೆರಿಕ್ ಬಳಕೆ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್ ಹೆಚ್ಚು ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ, ಅದು ನಿಮಗೆ ಇನ್ನಷ್ಟು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಶಕ್ತಿಯುತ ಕೋಡ್ ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಕೆಲವು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ:

ಬಹು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು

ನೀವು ಬಹು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳೊಂದಿಗೆ ಫಂಕ್ಷನ್‌ಗಳು ಅಥವಾ ಕ್ಲಾಸ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು:

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

interface Name {
  firstName: string;
}

interface Age {
  age: number;
}

const person: Name = { firstName: "Bob" };
const details: Age = { age: 42 };

const merged = merge(person, details);
console.log(merged.firstName); // ಔಟ್‌ಪುಟ್: Bob
console.log(merged.age); // ಔಟ್‌ಪುಟ್: 42

merge ಫಂಕ್ಷನ್ T ಮತ್ತು U ಪ್ರಕಾರಗಳ ಎರಡು ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಂಡು, ಎರಡೂ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಹೊಂದಿರುವ ಹೊಸ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇದು ವಿವಿಧ ಮೂಲಗಳಿಂದ ಡೇಟಾವನ್ನು ಸಂಯೋಜಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮಾರ್ಗವಾಗಿದೆ.

ಜೆನೆರಿಕ್ ನಿರ್ಬಂಧಗಳು

ಹಿಂದೆ ತೋರಿಸಿದಂತೆ, ನಿರ್ಬಂಧಗಳು ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಬಳಸಬಹುದಾದ ಪ್ರಕಾರಗಳನ್ನು ನಿರ್ಬಂಧಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ಜೆನೆರಿಕ್ ಕೋಡ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪ್ರಕಾರಗಳಲ್ಲಿ ಸುರಕ್ಷಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದೆಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

interface Lengthwise {
  length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length);
  return arg;
}

loggingIdentity([1, 2, 3]); // ಔಟ್‌ಪುಟ್: 3
loggingIdentity("hello"); // ಔಟ್‌ಪುಟ್: 5
// loggingIdentity(123); // ದೋಷ: 'number' ಪ್ರಕಾರದ ಆರ್ಗ್ಯುಮೆಂಟ್ 'Lengthwise' ಪ್ರಕಾರದ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗುವುದಿಲ್ಲ.

loggingIdentity ಫಂಕ್ಷನ್ T ಪ್ರಕಾರದ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅದು ಸಂಖ್ಯೆ ಪ್ರಕಾರದ length ಪ್ರಾಪರ್ಟಿಯನ್ನು ಹೊಂದಿರಬೇಕು. ಇದು ಫಂಕ್ಷನ್ length ಪ್ರಾಪರ್ಟಿಯನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದೆಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಜೆನೆರಿಕ್ ಕ್ಲಾಸ್‌ಗಳು

ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಕ್ಲಾಸ್‌ಗಳೊಂದಿಗೂ ಬಳಸಬಹುದು:

class DataStorage<T> {
  private data: T[] = [];

  addItem(item: T) {
    this.data.push(item);
  }

  removeItem(item: T) {
    this.data = this.data.filter(d => d !== item);
  }

  getItems(): T[] {
    return [...this.data];
  }
}

const textStorage = new DataStorage<string>();
textStorage.addItem("apple");
textStorage.addItem("banana");
textStorage.removeItem("apple");
console.log(textStorage.getItems()); // ಔಟ್‌ಪುಟ್: [ 'banana' ]

const numberStorage = new DataStorage<number>();
numberStorage.addItem(1);
numberStorage.addItem(2);
numberStorage.removeItem(1);
console.log(numberStorage.getItems()); // ಔಟ್‌ಪುಟ್: [ 2 ]

DataStorage ಕ್ಲಾಸ್ ಯಾವುದೇ T ಪ್ರಕಾರದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು. ಇದು ನಿಮಗೆ ಟೈಪ್-ಸೇಫ್ ಆಗಿರುವ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಡೇಟಾ ರಚನೆಗಳನ್ನು ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಜೆನೆರಿಕ್ ಇಂಟರ್ಫೇಸ್‌ಗಳು

ಜೆನೆರಿಕ್ ಇಂಟರ್ಫೇಸ್‌ಗಳು ವಿವಿಧ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಲ್ಲ ಕಾಂಟ್ರಾಕ್ಟ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಉಪಯುಕ್ತವಾಗಿವೆ. ಉದಾಹರಣೆಗೆ:

interface Result<T, E> {
  success: boolean;
  data?: T;
  error?: E;
}

interface User {
  id: number;
  username: string;
  email: string;
}

interface ErrorMessage {
  code: number;
  message: string;
}

function fetchUser(id: number): Result<User, ErrorMessage> {
  if (id === 1) {
    return { success: true, data: { id: 1, username: "john.doe", email: "john.doe@example.com" } };
  } else {
    return { success: false, error: { code: 404, message: "User not found" } };
  }
}

const userResult = fetchUser(1);
if (userResult.success) {
  console.log(userResult.data.username);
} else {
  console.log(userResult.error.message);
}

Result ಇಂಟರ್ಫೇಸ್ ಒಂದು ಆಪರೇಷನ್‌ನ ಫಲಿತಾಂಶವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಜೆನೆರಿಕ್ ರಚನೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಇದು T ಪ್ರಕಾರದ ಡೇಟಾ ಅಥವಾ E ಪ್ರಕಾರದ ದೋಷವನ್ನು ಒಳಗೊಂಡಿರಬಹುದು. ಅಸಿಂಕ್ರೋನಸ್ ಆಪರೇಷನ್‌ಗಳು ಅಥವಾ ವಿಫಲವಾಗಬಹುದಾದ ಆಪರೇಷನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಇದು ಒಂದು ಸಾಮಾನ್ಯ ಮಾದರಿಯಾಗಿದೆ.

ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್ ಮತ್ತು ಜೆನೆರಿಕ್ಸ್

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್‌ಗಳೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಹಲವಾರು ಅಂತರ್ನಿರ್ಮಿತ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಯುಟಿಲಿಟಿ ಟೈಪ್ಸ್‌ಗಳು ನಿಮಗೆ ಪ್ರಕಾರಗಳನ್ನು ಶಕ್ತಿಯುತ ರೀತಿಯಲ್ಲಿ ಪರಿವರ್ತಿಸಲು ಮತ್ತು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

Partial<T>

Partial<T> ಪ್ರಕಾರದ T ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ಐಚ್ಛಿಕ ಮಾಡುತ್ತದೆ:

interface Person {
  name: string;
  age: number;
}

type PartialPerson = Partial<Person>;

const partialPerson: PartialPerson = { name: "Alice" }; // ಮಾನ್ಯವಾಗಿದೆ

Readonly<T>

Readonly<T> ಪ್ರಕಾರದ T ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ರೀಡ್-ಓನ್ಲಿ ಮಾಡುತ್ತದೆ:

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = Readonly<Person>;

const readonlyPerson: ReadonlyPerson = { name: "Bob", age: 42 };
// readonlyPerson.age = 43; // ದೋಷ: 'age'ಗೆ ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ ಇದು ರೀಡ್-ಓನ್ಲಿ ಪ್ರಾಪರ್ಟಿಯಾಗಿದೆ.

Pick<T, K>

Pick<T, K> ಪ್ರಕಾರದ T ನಿಂದ K ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ:

interface Person {
  name: string;
  age: number;
  email: string;
}

type NameAndAge = Pick<Person, "name" | "age">;

const nameAndAge: NameAndAge = { name: "Charlie", age: 28 };

Omit<T, K>

Omit<T, K> ಪ್ರಕಾರದ T ನಿಂದ K ಪ್ರಾಪರ್ಟಿಗಳ ಗುಂಪನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ:

interface Person {
  name: string;
  age: number;
  email: string;
}

type PersonWithoutEmail = Omit<Person, "email">;

const personWithoutEmail: PersonWithoutEmail = { name: "David", age: 35 };

Record<K, T>

Record<K, T> ಕೀಗಳ K ಮತ್ತು T ಪ್ರಕಾರದ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಒಂದು ಪ್ರಕಾರವನ್ನು ರಚಿಸುತ್ತದೆ:

type CountryCodes = "US" | "CA" | "UK" | "DE" | "FR" | "JP" | "CN" | "IN" | "BR" | "AU"; // ಜಾಗತಿಕ ಸಂದರ್ಭಕ್ಕಾಗಿ ವಿಸ್ತೃತ ಪಟ್ಟಿ
type Currency = "USD" | "CAD" | "GBP" | "EUR" | "JPY" | "CNY" | "INR" | "BRL" | "AUD"; // ಜಾಗತಿಕ ಸಂದರ್ಭಕ್ಕಾಗಿ ವಿಸ್ತೃತ ಪಟ್ಟಿ

type CurrencyMap = Record<CountryCodes, Currency>;

const currencyMap: CurrencyMap = {
  "US": "USD",
  "CA": "CAD",
  "UK": "GBP",
  "DE": "EUR",
  "FR": "EUR",
  "JP": "JPY",
  "CN": "CNY",
  "IN": "INR",
  "BR": "BRL",
  "AU": "AUD",
};

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್

ಮ್ಯಾಪ್ಡ್ ಟೈಪ್ಸ್ ನಿಮಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರಗಳನ್ನು ಅವುಗಳ ಪ್ರಾಪರ್ಟಿಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವ ಮೂಲಕ ಪರಿವರ್ತಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪ್ರಕಾರಗಳನ್ನು ಆಧರಿಸಿ ಹೊಸ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮಾರ್ಗವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಇನ್ನೊಂದು ಪ್ರಕಾರದ ಎಲ್ಲಾ ಪ್ರಾಪರ್ಟಿಗಳನ್ನು ರೀಡ್-ಓನ್ಲಿ ಮಾಡುವ ಪ್ರಕಾರವನ್ನು ರಚಿಸಬಹುದು:

interface Person {
  name: string;
  age: number;
}

type ReadonlyPerson = {
  readonly [K in keyof Person]: Person[K];
};

const readonlyPerson: ReadonlyPerson = { name: "Eve", age: 25 };
// readonlyPerson.age = 26; // ದೋಷ: 'age'ಗೆ ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ ಇದು ರೀಡ್-ಓನ್ಲಿ ಪ್ರಾಪರ್ಟಿಯಾಗಿದೆ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, [K in keyof Person] ಎಂಬುದು Person ಇಂಟರ್ಫೇಸ್‌ನ ಎಲ್ಲಾ ಕೀಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುತ್ತದೆ, ಮತ್ತು Person[K] ಪ್ರತಿಯೊಂದು ಪ್ರಾಪರ್ಟಿಯ ಪ್ರಕಾರವನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ. readonly ಕೀವರ್ಡ್ ಪ್ರತಿಯೊಂದು ಪ್ರಾಪರ್ಟಿಯನ್ನು ರೀಡ್-ಓನ್ಲಿ ಮಾಡುತ್ತದೆ.

ಷರತ್ತುಬದ್ಧ ಟೈಪ್ಸ್

ಷರತ್ತುಬದ್ಧ ಟೈಪ್ಸ್ ನಿಮಗೆ ಷರತ್ತುಗಳನ್ನು ಆಧರಿಸಿ ಪ್ರಕಾರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮಾರ್ಗವಾಗಿದೆ.

type NonNullable<T> = T extends null | undefined ? never : T;

type MaybeString = string | null | undefined;
type StringType = NonNullable<MaybeString>; // string

function getValue<T>(value: T): NonNullable<T> {
  if (value == null) { // null ಮತ್ತು undefined ಎರಡನ್ನೂ ನಿಭಾಯಿಸುತ್ತದೆ
    throw new Error("ಮೌಲ್ಯವು null ಅಥವಾ undefined ಆಗಿರಬಾರದು");
  }
  return value as NonNullable<T>;
}

try {
  const validValue = getValue("hello");
  console.log(validValue.toUpperCase()); // ಔಟ್‌ಪುಟ್: HELLO

  const invalidValue = getValue(null); // ಇದು ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ
  console.log(invalidValue); // ಈ ಸಾಲು ತಲುಪುವುದಿಲ್ಲ
} catch (error: any) {
  console.error(error.message); // ಔಟ್‌ಪುಟ್: ಮೌಲ್ಯವು null ಅಥವಾ undefined ಆಗಿರಬಾರದು
}

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, NonNullable<T> ಪ್ರಕಾರವು T null ಅಥವಾ undefined ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಹಾಗಿದ್ದಲ್ಲಿ, ಅದು never ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಅಂದರೆ ಆ ಪ್ರಕಾರವನ್ನು ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ. ಇಲ್ಲದಿದ್ದರೆ, ಅದು T ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಇದು ನಿಮಗೆ ಖಚಿತವಾಗಿ ನಾನ್-ನಲ್ಲೇಬಲ್ ಆಗಿರುವ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಜೆನೆರಿಕ್ಸ್ ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಜೆನೆರಿಕ್ಸ್ ಬಳಸುವಾಗ ನೆನಪಿನಲ್ಲಿಡಬೇಕಾದ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ಇಲ್ಲಿವೆ:

• ವಿವರಣಾತ್ಮಕ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್ ಹೆಸರುಗಳನ್ನು ಬಳಸಿ: ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಉದ್ದೇಶವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸುವ ಹೆಸರುಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿ.
• ಜೆನೆರಿಕ್ ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಬಳಸಬಹುದಾದ ಪ್ರಕಾರಗಳನ್ನು ಮಿತಿಗೊಳಿಸಲು ನಿರ್ಬಂಧಗಳನ್ನು ಬಳಸಿ: ಇದು ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಕೋಡ್ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪ್ರಕಾರಗಳಲ್ಲಿ ಸುರಕ್ಷಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದೆಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
• ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಕೋಡ್ ಅನ್ನು ಸರಳ ಮತ್ತು ಕೇಂದ್ರೀಕೃತವಾಗಿಡಿ: ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಕೋಡ್ ಅನ್ನು ಹಲವಾರು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು ಅಥವಾ ಸಂಕೀರ್ಣ ನಿರ್ಬಂಧಗಳೊಂದಿಗೆ ಅತಿಯಾಗಿ ಸಂಕೀರ್ಣಗೊಳಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ.
• ನಿಮ್ಮ ಜೆನೆರಿಕ್ ಕೋಡ್ ಅನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ದಾಖಲಿಸಿ: ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಉದ್ದೇಶ ಮತ್ತು ಬಳಸಲಾದ ಯಾವುದೇ ನಿರ್ಬಂಧಗಳನ್ನು ವಿವರಿಸಿ.
• ಕೋಡ್ ಮರುಬಳಕೆ ಮತ್ತು ಟೈಪ್ ಸೇಫ್ಟಿ ನಡುವಿನ ವಿನಿಮಯವನ್ನು ಪರಿಗಣಿಸಿ: ಜೆನೆರಿಕ್ಸ್ ಕೋಡ್ ಮರುಬಳಕೆಯನ್ನು ಸುಧಾರಿಸಬಹುದಾದರೂ, ಅವು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಸಂಕೀರ್ಣಗೊಳಿಸಬಹುದು. ಜೆನೆರಿಕ್ಸ್ ಬಳಸುವ ಮೊದಲು ಪ್ರಯೋಜನಗಳು ಮತ್ತು ಅನಾನುಕೂಲಗಳನ್ನು ಅಳೆಯಿರಿ.
• ಸ್ಥಳೀಕರಣ ಮತ್ತು ಜಾಗತೀಕರಣವನ್ನು (l10n ಮತ್ತು g11n) ಪರಿಗಣಿಸಿ: ವಿವಿಧ ಪ್ರದೇಶಗಳಲ್ಲಿನ ಬಳಕೆದಾರರಿಗೆ ಪ್ರದರ್ಶಿಸಬೇಕಾದ ಡೇಟಾದೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ, ನಿಮ್ಮ ಜೆನೆರಿಕ್ಸ್ ಸೂಕ್ತ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕ ಸಂಪ್ರದಾಯಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಉದಾಹರಣೆಗೆ, ಸಂಖ್ಯೆ ಮತ್ತು ದಿನಾಂಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಸ್ಥಳೀಯತೆಗಳಾದ್ಯಂತ ಗಮನಾರ್ಹವಾಗಿ ಬದಲಾಗಬಹುದು.

ಜಾಗತಿಕ ಸಂದರ್ಭದಲ್ಲಿ ಉದಾಹರಣೆಗಳು

ಜಾಗತಿಕ ಸಂದರ್ಭದಲ್ಲಿ ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದರ ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ಪರಿಗಣಿಸೋಣ:

ಕರೆನ್ಸಿ ಪರಿವರ್ತನೆ

interface ConversionRate {
  rate: number;
  fromCurrency: string;
  toCurrency: string;
}

function convertCurrency<T extends ConversionRate>(amount: number, rate: T): number {
  return amount * rate.rate;
}

const usdToEurRate: ConversionRate = { rate: 0.85, fromCurrency: "USD", toCurrency: "EUR" };
const amountInUSD = 100;
const amountInEUR = convertCurrency(amountInUSD, usdToEurRate);
console.log(`${amountInUSD} USD is equal to ${amountInEUR} EUR`); // ಔಟ್‌ಪುಟ್: 100 USD is equal to 85 EUR

ದಿನಾಂಕ ಫಾರ್ಮ್ಯಾಟಿಂಗ್

interface DateFormatOptions {
  locale: string;
  options: Intl.DateTimeFormatOptions;
}

function formatDate<T extends DateFormatOptions>(date: Date, format: T): string {
  return date.toLocaleDateString(format.locale, format.options);
}

const currentDate = new Date();

const usDateFormat: DateFormatOptions = { locale: "en-US", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const germanDateFormat: DateFormatOptions = { locale: "de-DE", options: { year: 'numeric', month: 'long', day: 'numeric' } };
const japaneseDateFormat: DateFormatOptions = { locale: "ja-JP", options: { year: 'numeric', month: 'long', day: 'numeric' } };

console.log("US Date: " + formatDate(currentDate, usDateFormat));
console.log("German Date: " + formatDate(currentDate, germanDateFormat));
console.log("Japanese Date: " + formatDate(currentDate, japaneseDateFormat));

ಅನುವಾದ ಸೇವೆ

interface Translation {
  [key: string]: string; // ಡೈನಾಮಿಕ್ ಭಾಷಾ ಕೀಗಳಿಗೆ ಅನುಮತಿಸುತ್ತದೆ
}

interface LanguageData<T extends Translation> {
  languageCode: string;
  translations: T;
}

const englishTranslations: Translation = {
  "hello": "Hello",
  "goodbye": "Goodbye",
  "welcome": "Welcome to our website!"
};

const spanishTranslations: Translation = {
  "hello": "Hola",
  "goodbye": "Adiós",
  "welcome": "¡Bienvenido a nuestro sitio web!"
};

const frenchTranslations: Translation = {
  "hello": "Bonjour",
  "goodbye": "Au revoir",
  "welcome": "Bienvenue sur notre site web !"
};


const languageData: LanguageData<typeof englishTranslations>[] = [
  {languageCode: "en", translations: englishTranslations },
  {languageCode: "es", translations: spanishTranslations },
  {languageCode: "fr", translations: frenchTranslations}
];

function translate<T extends Translation>(key: string, languageCode: string, languageData: LanguageData<T>[]): string {
  const lang = languageData.find(lang => lang.languageCode === languageCode);
  if (!lang) {
    return `Translation for ${key} in ${languageCode} not found.`;
  }
  return lang.translations[key] || `Translation for ${key} not found.`;
}

console.log(translate("hello", "en", languageData)); // ಔಟ್‌ಪುಟ್: Hello
console.log(translate("hello", "es", languageData)); // ಔಟ್‌ಪುಟ್: Hola
console.log(translate("welcome", "fr", languageData)); // ಔಟ್‌ಪುಟ್: Bienvenue sur notre site web !
console.log(translate("missingKey", "de", languageData)); // ಔಟ್‌ಪುಟ್: Translation for missingKey in de not found.

ತೀರ್ಮಾನ

ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ಸ್ ಸಂಕೀರ್ಣ ಡೇಟಾ ಪ್ರಕಾರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಲ್ಲ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ, ಟೈಪ್-ಸೇಫ್ ಕೋಡ್ ಬರೆಯಲು ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದೆ. ಜೆನೆರಿಕ್ಸ್‌ಗಳ ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್, ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನಿಮ್ಮ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಗುಣಮಟ್ಟ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ನೀವು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸಬಹುದು. ಜಾಗತಿಕ ಪ್ರೇಕ್ಷಕರಿಗಾಗಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ, ಜೆನೆರಿಕ್ಸ್ ನಿಮಗೆ ವೈವಿಧ್ಯಮಯ ಡೇಟಾ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳು ಮತ್ತು ಸಾಂಸ್ಕೃತಿಕ ಸಂಪ್ರದಾಯಗಳನ್ನು ನಿಭಾಯಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಪ್ರತಿಯೊಬ್ಬರಿಗೂ ಸುಗಮ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ.